home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-04 / pxewin.zip / PXFIELD.HPP < prev    next >
C/C++ Source or Header  |  1992-02-06  |  16KB  |  534 lines
  1. // PXEWIN - (C) Copyright 1992 by Beam Engineering, INC.
  2.  
  3. // PXFIELD.HPP //
  4.  
  5. // Contents ----------------------------------------------------------------
  6. //
  7. //    This module contains the following classes:
  8. //
  9. //    1.  PXField.  This is the general field class for dispatching the
  10. //    field type to the correct field class.
  11. //
  12. //    2.  PXFieldTypeBase.  This is the base class for all field types.
  13. //
  14. //    3.  PXFieldTypeChar.  For character type fields.
  15. //
  16. //    4.  PXFieldTypeLong.  For long type fields.
  17. //
  18. //    5.  PXFieldTypeShort.  For short type fields.
  19. //
  20. //    6.  PXFieldTypeDouble.  For double type fields.
  21. //
  22. //    7.  PXFieldTypeDate.  For date type fields.
  23. //
  24. //    All Puts and gets to fields start or end with character data.  This
  25. //    is a basic design constrient of the PXEWIN library.  Character data
  26. //    is sufficient for most browsing and editing functionality.
  27. //
  28. // End ---------------------------------------------------------------------
  29.  
  30. // External Reference Name for this Header ---------------------------------
  31.  
  32. #ifndef PXFIELD_HPP
  33.     #define PXFIELD_HPP
  34.  
  35. // End ---------------------------------------------------------------------
  36.  
  37. // Interface Dependencies --------------------------------------------------
  38.  
  39. #ifndef PXEOBJ_HPP
  40.     #include "pxeobj.hpp"
  41. #endif // PXEOBJ_HPP //
  42.  
  43. // End ---------------------------------------------------------------------
  44.  
  45. // class PXField //
  46.  
  47. _CLASSDEF(PXFieldTypeBase)
  48. class PXFieldTypeBase;
  49.  
  50. #define MAX_FLD_NAME_SIZE 26            /* This is the maximum size
  51.                            of a field name */
  52. #define MAX_FLD_TYPE_SIZE 6            /* The maximum size of a
  53.                            field type */
  54.  
  55. _CLASSDEF(PXField)
  56. class PXField:public PXEngObject
  57. {
  58. private:
  59.     virtual const Pchar streamableName()
  60.     const                    /* Defines the streamable
  61.                            name for this class. */
  62.     {
  63.         return "PXField";
  64.     }
  65. protected:
  66.     FIELDHANDLE fld;            /* The field handle */
  67.     Pchar fldtype;                /* Field type indentifier */
  68.     Pchar fldname;                /* The name of the field */
  69.                         /* Base point for field
  70.                            types */
  71.     PPXFieldTypeBase my_type;
  72.     virtual Pvoid read(Ripstream);        /* Read persistant object */
  73.     virtual void write(Ropstream);        /* Write persistant object */
  74.     PXField(StreamableInit):        /* Persistant object
  75.                            constructor */
  76.         PXEngObject(streamableInit)
  77.     {
  78.  
  79.     }
  80. public:
  81.                         /* Pass the Record object and
  82.                            field handle to the
  83.                            constuctor. */
  84.     PXField(PPXRec my_object,
  85.     FIELDHANDLE FldHandle);
  86.     PXField(PPXField my_field);        /* Analogous to a copy
  87.                            constructor so that
  88.                            derived types can
  89.                            reference back to the
  90.                            parent. */
  91.     static PTStreamable build();        /* Build persistant object */
  92.     ~PXField(void);
  93.     int RetCharSize();            /* Return the size of this
  94.                            field in characters */
  95.     Pchar RetName()                /* Return field name */
  96.     {
  97.         return fldname;
  98.     }
  99.     Pchar Get();                /* Get the field data */
  100.     virtual void PXError(int org);        /* PXField error handler */
  101. };
  102.  
  103. // Description -------------------------------------------------------------
  104. //
  105. //    This class contains constructors, destructors and members needed to
  106. //    access a field in a Paradox table.  It uses PXENGINE function calls.
  107. //    The main purpose of this class is to figure out what type of field
  108. //    object you have and provide a generic field class for all field
  109. //    types to derive themselves from.  You can make an array of fields
  110. //    with a common data type.
  111. //
  112. // End ---------------------------------------------------------------------
  113.  
  114. typedef PXField _FAR **PPPXField;               /* You'll need this for a
  115.                            DLL compatible array of
  116.                            fields. */
  117.  
  118. // Define inserters and extractors for persistant objects:
  119.  
  120. inline Ripstream operator >> (Ripstream is,RPXField cl)
  121.     {return is >> (RTStreamable)cl;}
  122.  
  123. inline Ripstream operator >> (Ripstream is,RPPXField cl)
  124.     {return is >> (RPvoid)cl;}
  125.  
  126. inline Ropstream operator << (Ropstream os,RPXField cl)
  127.     {return os << (RTStreamable)cl;}
  128.  
  129. inline Ropstream operator << (Ropstream os,PPXField cl)
  130.     {return os << (PTStreamable)cl;}
  131.  
  132. // class PXFieldTypeBase //
  133.  
  134. class PXFieldTypeBase:public PXField
  135. {
  136. private:
  137.     virtual const Pchar streamableName()
  138.     const                    /* Defines the streamable
  139.                            name for this class. */
  140.     {
  141.         return "PXFieldTypeBase";
  142.     }
  143. protected:
  144.     int size;                /* Size of storage area */
  145.     int char_size;                /* This is the maximum size
  146.                            of the field after it has
  147.                            been converted to
  148.                            character data */
  149.     Pchar char_dat;                /* Character version of data
  150.                         */
  151.     virtual Pvoid read(Ripstream);        /* Read persistant object */
  152.     virtual void write(Ropstream);        /* Write persistant object */
  153.     PXFieldTypeBase(StreamableInit):    /* Persistant object
  154.                            constructor */
  155.         PXField(streamableInit)
  156.     {
  157.  
  158.     }
  159. public:
  160.                         /* Constructor references
  161.                            back to PXField class */
  162.     PXFieldTypeBase(PPXField my_field):
  163.         PXField(my_field)
  164.     {
  165.  
  166.     }
  167.     static PTStreamable build();        /* Build persistant object */
  168.     virtual int Get(void)            /* Get the data */
  169.     {
  170.         return PXSUCCESS;
  171.     }
  172.     virtual int Put(void)            /* Put the data */
  173.     {
  174.         return PXSUCCESS;
  175.     }
  176.     int RetCharSize()            /* Return character size */
  177.     {
  178.         return char_size;
  179.     }
  180.     Pchar RetCharData()             /* Returns character data */
  181.     {
  182.         return char_dat;
  183.     }
  184. };
  185.  
  186. // Description -------------------------------------------------------------
  187. //
  188. //    The PXFieldTypeBase defines the base class for getting and putting
  189. //    fields of different types to and from the database.  Each of the
  190. //    data type specific functions are spec'ed out in the preceding
  191. //    classes.  Members Put and Get could have been defined as pure
  192. //    virtuals since they serve only as place holders for derived types.
  193. //    The only reason for declaring them as such is for virtual error
  194. //    dispatching back to the MDI frame window.  This would lead to a
  195. //    compiler error because you would be making an instance of a abstract
  196. //    class.
  197. //
  198. // End ---------------------------------------------------------------------
  199.  
  200. // Define inserters and extractors for persistant objects:
  201.  
  202. inline Ripstream operator >> (Ripstream is,RPXFieldTypeBase cl)
  203.     {return is >> (RTStreamable)cl;}
  204.  
  205. inline Ripstream operator >> (Ripstream is,RPPXFieldTypeBase cl)
  206.     {return is >> (RPvoid)cl;}
  207.  
  208. inline Ropstream operator << (Ropstream os,RPXFieldTypeBase cl)
  209.     {return os << (RTStreamable)cl;}
  210.  
  211. inline Ropstream operator << (Ropstream os,PPXFieldTypeBase cl)
  212.     {return os << (PTStreamable)cl;}
  213.  
  214. // class PXFieldTypeChar //
  215.  
  216. _CLASSDEF(PXFieldTypeChar)
  217. class PXFieldTypeChar:public PXFieldTypeBase
  218. {
  219. private:
  220.     Pchar data;                /* Data buffer */
  221.     virtual const Pchar streamableName()
  222.     const                    /* Defines the streamable
  223.                            name for this class. */
  224.     {
  225.         return "PXFieldTypeChar";
  226.     }
  227. protected:
  228.     virtual Pvoid read(Ripstream);        /* Read persistant object */
  229.     virtual void write(Ropstream);        /* Write persistant object */
  230.     PXFieldTypeChar(StreamableInit):    /* Persistant object
  231.                            constructor */
  232.         PXFieldTypeBase(streamableInit)
  233.     {
  234.  
  235.     }
  236. public:
  237.                         /* constructor references
  238.                            back to PXField parent
  239.                            object.  The sz parameter
  240.                            is for the size of the
  241.                            string. */
  242.     PXFieldTypeChar(PPXField my_field,int sz);
  243.     ~PXFieldTypeChar(void);
  244.     static PTStreamable build();        /* Build persistant object */
  245.                         /* Get data into buffer from
  246.                            database */
  247.     int Get(void);
  248.                         /* Put your character data
  249.                            in the record buffer */
  250.     int Put(void);
  251. };
  252.  
  253. // Description -------------------------------------------------------------
  254. //
  255. //    This class spec's out getting and putting functions for character
  256. //    type data.
  257. //
  258. // End ---------------------------------------------------------------------
  259.  
  260. // Define inserters and extractors for persistant objects:
  261.  
  262. inline Ripstream operator >> (Ripstream is,RPXFieldTypeChar cl)
  263.     {return is >> (RTStreamable)cl;}
  264.  
  265. inline Ripstream operator >> (Ripstream is,RPPXFieldTypeChar cl)
  266.     {return is >> (RPvoid)cl;}
  267.  
  268. inline Ropstream operator << (Ropstream os,RPXFieldTypeChar cl)
  269.     {return os << (RTStreamable)cl;}
  270.  
  271. inline Ropstream operator << (Ropstream os,PPXFieldTypeChar cl)
  272.     {return os << (PTStreamable)cl;}
  273.  
  274.  
  275. // class PXFieldTypeDouble //
  276.  
  277. #define DOUBLE_SIZE 21                /* Maximum number of
  278.                            characters it takes to
  279.                            display this field
  280.                            including a decimal point,
  281.                            a minus sign, and 5
  282.                            commas.
  283.                         */
  284.  
  285. _CLASSDEF(PXFieldTypeDouble)
  286. class PXFieldTypeDouble:public PXFieldTypeBase
  287. {
  288. private:
  289.     Pdouble data;                /* Data buffer */
  290.     virtual const Pchar streamableName()
  291.     const                    /* Defines the streamable
  292.                            name for this class. */
  293.     {
  294.         return "PXFieldTypeDouble";
  295.     }
  296. protected:
  297.     virtual Pvoid read(Ripstream);        /* Read persistant object */
  298.     virtual void write(Ropstream);        /* Write persistant object */
  299.     PXFieldTypeDouble(StreamableInit):    /* Persistant object
  300.                            constructor */
  301.         PXFieldTypeBase(streamableInit)
  302.     {
  303.  
  304.     }
  305. public:
  306.                         /* Constructor references
  307.                            back to parent */
  308.     PXFieldTypeDouble(PPXField my_field);
  309.     ~PXFieldTypeDouble(void);
  310.                         /* Get data into buffer from
  311.                            database */
  312.     static PTStreamable build();        /* Build persistant object */
  313.     int Get(void);
  314.                         /* Put your data in the
  315.                            record buffer */
  316.     int Put(void);
  317. };
  318.  
  319. // Description -------------------------------------------------------------
  320. //
  321. //    This class spec's out getting and putting functions for double type
  322. //    data.
  323. //
  324. // End ---------------------------------------------------------------------
  325.  
  326. // Define inserters and extractors for persistant objects:
  327.  
  328. inline Ripstream operator >> (Ripstream is,RPXFieldTypeDouble cl)
  329.     {return is >> (RTStreamable)cl;}
  330.  
  331. inline Ripstream operator >> (Ripstream is,RPPXFieldTypeDouble cl)
  332.     {return is >> (RPvoid)cl;}
  333.  
  334. inline Ropstream operator << (Ropstream os,RPXFieldTypeDouble cl)
  335.     {return os << (RTStreamable)cl;}
  336.  
  337. inline Ropstream operator << (Ropstream os,PPXFieldTypeDouble cl)
  338.     {return os << (PTStreamable)cl;}
  339.  
  340.  
  341. // class PXFieldTypeLong //
  342.  
  343. #define LONGSIZE    14            /* Maximum number of
  344.                            characters it would take
  345.                            to display a long number
  346.                            including a decimal point
  347.                            (if you are using $'s),
  348.                            a minus sign, and 3
  349.                            commas.
  350.                         */
  351.  
  352. _CLASSDEF(PXFieldTypeLong)
  353. class PXFieldTypeLong:public PXFieldTypeBase
  354. {
  355. private:
  356.     Plong data;                /* Data buffer */
  357.     virtual const Pchar streamableName()
  358.     const                    /* Defines the streamable
  359.                            name for this class. */
  360.     {
  361.         return "PXFieldTypeLong";
  362.     }
  363. protected:
  364.     virtual Pvoid read(Ripstream);        /* Read persistant object */
  365.     virtual void write(Ropstream);        /* Write persistant object */
  366.     PXFieldTypeLong(StreamableInit):    /* Persistant object
  367.                            constructor */
  368.         PXFieldTypeBase(streamableInit)
  369.     {
  370.  
  371.     }
  372. public:
  373.     PXFieldTypeLong(PPXField my_field);    /* Constructor references
  374.                            back to parent. */
  375.     ~PXFieldTypeLong(void);
  376.     static PTStreamable build();        /* Build persistant object */
  377.                         /* Get data into buffer from
  378.                            database */
  379.     int Get(void);
  380.                         /* Put your data in the
  381.                            record buffer */
  382.     int Put(void);
  383. };
  384.  
  385. // Description -------------------------------------------------------------
  386. //
  387. //    This class spec's out getting and putting functions for long type
  388. //    data.
  389. //
  390. // End ---------------------------------------------------------------------
  391.  
  392. // Define inserters and extractors for persistant objects:
  393.  
  394. inline Ripstream operator >> (Ripstream is,RPXFieldTypeLong cl)
  395.     {return is >> (RTStreamable)cl;}
  396.  
  397. inline Ripstream operator >> (Ripstream is,RPPXFieldTypeLong cl)
  398.     {return is >> (RPvoid)cl;}
  399.  
  400. inline Ropstream operator << (Ropstream os,RPXFieldTypeLong cl)
  401.     {return os << (RTStreamable)cl;}
  402.  
  403. inline Ropstream operator << (Ropstream os,PPXFieldTypeLong cl)
  404.     {return os << (PTStreamable)cl;}
  405.  
  406.  
  407. // class PXFieldTypeShort //
  408.  
  409. #define SHORT_SIZE    8            /* Maximum number of
  410.                            characters it would take
  411.                            to represent a short
  412.                            number including a minus
  413.                            sign, a comma, and a
  414.                            decimal point (if you
  415.                            wish to format the data
  416.                            futher). */
  417.  
  418. _CLASSDEF(PXFieldTypeShort)
  419. class PXFieldTypeShort:public PXFieldTypeBase
  420. {
  421. private:
  422.     Pshort data;                /* Data buffer */
  423.     virtual const Pchar streamableName()
  424.     const                    /* Defines the streamable
  425.                            name for this class. */
  426.     {
  427.         return "PXFieldTypeShort";
  428.     }
  429. protected:
  430.     virtual Pvoid read(Ripstream);        /* Read persistant object */
  431.     virtual void write(Ropstream);        /* Write persistant object */
  432.     PXFieldTypeShort(StreamableInit):    /* Persistant object
  433.                            constructor */
  434.         PXFieldTypeBase(streamableInit)
  435.     {
  436.  
  437.     }
  438. public:
  439.     PXFieldTypeShort(PPXField my_field);    /* Constructor refences back
  440.                            to parent. */
  441.     ~PXFieldTypeShort(void);
  442.     static PTStreamable build();        /* Build persistant object */
  443.                         /* Get data into buffer from
  444.                            database */
  445.     int Get(void);
  446.                         /* Put your data in the
  447.                            record buffer */
  448.     int Put(void);
  449. };
  450.  
  451. // Description -------------------------------------------------------------
  452. //
  453. //    This class spec's out getting and putting functions for short type
  454. //    data.
  455. //
  456. // End ---------------------------------------------------------------------
  457.  
  458. // Define inserters and extractors for persistant objects:
  459.  
  460. inline Ripstream operator >> (Ripstream is,RPXFieldTypeShort cl)
  461.     {return is >> (RTStreamable)cl;}
  462.  
  463. inline Ripstream operator >> (Ripstream is,RPPXFieldTypeShort cl)
  464.     {return is >> (RPvoid)cl;}
  465.  
  466. inline Ropstream operator << (Ropstream os,RPXFieldTypeShort cl)
  467.     {return os << (RTStreamable)cl;}
  468.  
  469. inline Ropstream operator << (Ropstream os,PPXFieldTypeShort cl)
  470.     {return os << (PTStreamable)cl;}
  471.  
  472.  
  473. // class PXFieldTypeDate //
  474.  
  475. #define DATE_SIZE    10            /* Maximum number of
  476.                            characters you would need
  477.                            to define a date (i.e.
  478.                            12-03-1989). */
  479.  
  480. _CLASSDEF(PXFieldTypeDate)
  481. class PXFieldTypeDate:public PXFieldTypeBase
  482. {
  483. private:
  484.     PDATES data;                /* Data buffer */
  485.     virtual const Pchar streamableName()
  486.     const                    /* Defines the streamable
  487.                            name for this class. */
  488.     {
  489.         return "PXFieldTypeDate";
  490.     }
  491. protected:
  492.     virtual Pvoid read(Ripstream);        /* Read persistant object */
  493.     virtual void write(Ropstream);        /* Write persistant object */
  494.     PXFieldTypeDate(StreamableInit):    /* Persistant object
  495.                            constructor */
  496.         PXFieldTypeBase(streamableInit)
  497.     {
  498.  
  499.     }
  500. public:
  501.     PXFieldTypeDate(PPXField my_field);    /* Constructor references
  502.                            back to parent. */
  503.     ~PXFieldTypeDate(void);
  504.     static PTStreamable build();        /* Build persistant object */
  505.                         /* Get your DATE data
  506.                            from record buffer */
  507.     int Get(void);
  508.                         /* Put your double data in
  509.                            the record buffer */
  510.     int Put(void);
  511. };
  512.  
  513. // Description -------------------------------------------------------------
  514. //
  515. //    This class spec's out getting and putting functions for DATES type
  516. //    data.
  517. //
  518. // End ---------------------------------------------------------------------
  519.  
  520. // Define inserters and extractors for persistant objects:
  521.  
  522. inline Ripstream operator >> (Ripstream is,RPXFieldTypeDate cl)
  523.     {return is >> (RTStreamable)cl;}
  524.  
  525. inline Ripstream operator >> (Ripstream is,RPPXFieldTypeDate cl)
  526.     {return is >> (RPvoid)cl;}
  527.  
  528. inline Ropstream operator << (Ropstream os,RPXFieldTypeDate cl)
  529.     {return os << (RTStreamable)cl;}
  530.  
  531. inline Ropstream operator << (Ropstream os,PPXFieldTypeDate cl)
  532.     {return os << (PTStreamable)cl;}
  533.  
  534. #endif // PXFIELD.HPP //